// Node.js
const fs = require('fs');

const input = fs.readFileSync(0, 'utf8').trim().split(/\s+/).map(Number);
let ptr = 0;

const n = input[ptr++], m = input[ptr++], K = input[ptr++];
const reds = [];
for (let i = 0; i < m; i++) reds.push(input[ptr++]);

// 邻接表
const g = Array.from({ length: n + 1 }, () => []);
for (let i = 0; i < n - 1; i++) {
  const u = input[ptr++], v = input[ptr++], w = input[ptr++];
  g[u].push([v, w]);
  g[v].push([u, w]);
}

// 二叉堆（小根堆）
class MinHeap {
  constructor() { this.a = []; }
  size() { return this.a.length; }
  push(node) { // node: [dist, v]
    const a = this.a;
    a.push(node);
    let i = a.length - 1;
    while (i > 0) {
      const p = (i - 1) >> 1;
      if (a[p][0] <= a[i][0]) break;
      [a[p], a[i]] = [a[i], a[p]];
      i = p;
    }
  }
  pop() {
    const a = this.a;
    const top = a[0];
    const x = a.pop();
    if (a.length) {
      a[0] = x;
      let i = 0;
      while (true) {
        let l = i * 2 + 1, r = l + 1, s = i;
        if (l < a.length && a[l][0] < a[s][0]) s = l;
        if (r < a.length && a[r][0] < a[s][0]) s = r;
        if (s === i) break;
        [a[s], a[i]] = [a[i], a[s]];
        i = s;
      }
    }
    return top;
  }
}

const heap = new MinHeap();
// 初始化：所有红点距离为 0
for (const r of reds) heap.push([0, r]);

// 对每个结点统计前 K 个最短距离之和
const cnt = new Int16Array(n + 1);   // 已记录的个数（K ≤ 100，用 Int16 即可）
const sum = new Array(n + 1).fill(0n); // 用 BigInt 防止权重和溢出（权重 ≤ 1e6）

while (heap.size()) {
  const [d, u] = heap.pop();
  if (cnt[u] >= K) continue;          // 该结点的前 K 个距离已经够了
  cnt[u]++;                            // 记录本次最短距离
  sum[u] += BigInt(d);
  if (cnt[u] < K) {                    // 还没凑够 K，就继续从这里向外扩展
    for (const [v, w] of g[u]) {
      heap.push([d + w, v]);
    }
  } else {
    // 即使已经达到 K，也不再从 u 扩展；但别的源通过别的路径仍会到达其它点
  }
}

// 输出
console.log(
  Array.from({ length: n }, (_, i) => sum[i + 1].toString()).join(' ')
);
